home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Plus 1999 #2
/
Amiga Plus CD - 1999 - No. 2.iso
/
System-Boost
/
Workbench
/
TinyMeter
/
Source
/
TinyMeter_main
/
handler.c
< prev
next >
Wrap
C/C++ Source or Header
|
1997-02-27
|
25KB
|
792 lines
#include <intuition/classusr.h>
#include <intuition/gadgetclass.h>
#include <intuition/cghooks.h>
#include <intuition/icclass.h>
#include <intuition/classes.h>
#include <utility/tagitem.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <dos/dos.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <dos/notify.h>
#include <intuition/intuition.h>
#include <libraries/SysInfo.h>
#include <utility/tagitem.h>
#include <clib/macros.h>
#include <libraries/commodities.h>
#include <libraries/ScreenNotify.h>
#include <datatypes/datatypesclass.h>
#include <datatypes/datatypes.h>
#include <datatypes/pictureclass.h>
#include <workbench/workbench.h>
#include <workbench/startup.h>
#include "gaugeclass.h"
#include "launchclass.h"
#include "tinymeter.h"
#define test_test 0
#define test_getwin 1
#define do_clock 1
#define do_mem 2
#define do_vol 3
struct TestMessage
{
struct Message ts_Message;
ULONG MethodID;
struct tm_sys_set *set;
struct tm_gau_set *list;
ULONG posx,
posy,
sizx;
};
void init_time_request(struct timerequest *my_time_request_clock, ULONG my_time_mask_clock)
{
ULONG interval;
my_time_request_clock -> tr_node.io_Command = TR_GETSYSTIME;
DoIO((struct IORequest *)my_time_request_clock);
interval=my_time_request_clock -> tr_time.tv_secs;
my_time_request_clock -> tr_node.io_Command = TR_ADDREQUEST;
my_time_request_clock -> tr_time.tv_secs = interval+1;
my_time_request_clock -> tr_time.tv_micro = NULL;
SetSignal(NULL,my_time_mask_clock);
SendIO((struct IORequest *)my_time_request_clock);
}
ULONG snapSub(struct tm_sys_set *set, struct tm_data *data)
{
struct lau_enty *list;
int i;
struct IntuiMessage *m;
while((m=(struct IntuiMessage *)GetMsg( data->win->UserPort ))) ReplyMsg( (struct Message *)m );
data->win=(struct Window *) snapBackground(set,data);
drawBackground(set,data);
for(i=NULL;i<data->num_of_gaug;i++)
{
if(data->gdg[i])
{
GetAttr(LAU_List,data->gdg[i],(ULONG *)&list);
if(list) AddGList(data->win,data->gdg[i],0,1,NULL);
else AddGList(data->win,data->gdg[i],-1,1,NULL);
SetAttrs(data->gdg[i],GA_Width, data->gauge_x_size, NULL);
}
}
RefreshGList(data->win->FirstGadget,data->win,NULL,-1);
return((ULONG)1L << data->win->UserPort->mp_SigBit);
}
void setBase(struct tm_data *data)
{
int i;
ULONG cur;
for(i=NULL;i<data->num_of_gaug;i++)
{
if(data->gdg[i])
{
GetAttr(GAU_Current,data->gdg[i],&cur);
SetAttrs(data->gdg[i],GAU_Current,cur,GAU_Base,cur,TAG_DONE);
}
}
RefreshGList(data->win->FirstGadget,data->win,NULL,-1);
}
void handle_launcher(struct tm_data *data, WORD ID, struct Gadget *obj,struct WBArg *wbarg, ULONG numarg)
{
struct Window *lwin;
struct RastPort *rp,
tmpras;
BOOL foo=TRUE,
start=FALSE;
struct lau_entry *entry,
*foobar;
LONG dummy,
height,
width;
LONG x,
y,
selected,
sigs,
lastsel;
ULONG pen_bg,
pen_bright,
pen_dark,
pen_cur,
pen_entry,
window_mask,
lwindow_mask,
down,trans;
UWORD entryheight,
iw=NULL,
y_pos;
struct IntuiMessage *m;
struct BitMapHeader *bmhd;
struct MsgPort *appport;
struct AppWindow *appwin;
ULONG appwinsig;
GetAttr(LAU_ColEntry ,obj,(ULONG *)&pen_entry);
GetAttr(LAU_ColBrightEdg ,obj,(ULONG *)&pen_bright);
GetAttr(LAU_ColDarkEdg ,obj,(ULONG *)&pen_dark);
GetAttr(LAU_ColBackground,obj,(ULONG *)&pen_bg);
GetAttr(LAU_ColCursor ,obj,(ULONG *)&pen_cur);
GetAttr(LAU_List ,obj,(ULONG *)&entry);
GetAttr(LAU_Down ,obj,(ULONG *)&down);
GetAttr(LAU_Transparent ,obj,(ULONG *)&trans);
if((foobar=entry)&&(ID>-1))
{
InitRastPort(&tmpras);
SetFont(&tmpras,data->Font[ID]);
dummy=NULL;
entryheight=data->Font[ID]->tf_YSize;
width=data->gdg[ID]->Width+2;
do
{
if(foobar->img)
{
GetDTAttrs(foobar->img,PDTA_BitMapHeader,(ULONG *)&bmhd,TAG_DONE);
if(bmhd)
{
entryheight=MAX(entryheight,bmhd->bmh_Height+2);
iw=MAX(iw,bmhd->bmh_Width+6);
}
}
foobar->width=TextLength(&tmpras,foobar->lau_lbl,my_strlen(foobar->lau_lbl));
width=MAX(width,foobar->width+12+iw);
dummy++;
}
while(foobar=foobar->next);
y_pos=((entryheight-((data->Font[ID]->tf_Baseline+data->Font[ID]->tf_YSize)>>1))>>1);
if(data->Font[ID]->tf_Baseline<data->Font[ID]->tf_YSize)
{
y_pos+=data->Font[ID]->tf_Baseline-1;
if(y_pos<data->Font[ID]->tf_Baseline)y_pos=data->Font[ID]->tf_Baseline;
}
else
{
y_pos+=data->Font[ID]->tf_YSize-1;
if(y_pos<data->Font[ID]->tf_YSize) y_pos=data->Font[ID]->tf_YSize;
}
height=(entryheight*dummy)+2;
y=data->gdg[ID]->TopEdge+data->win->TopEdge-( down==lau_up ? height : ( down== lau_down ? -data->gdg[ID]->Height : height>>1 ));
if((lwin=(struct Window *)OpenWindowTags(NULL,
WA_Left, data->gdg[ID]->LeftEdge+data->win->LeftEdge-1,
WA_Top, y,
WA_Width, width,
WA_Height, height,
WA_Flags, WFLG_BORDERLESS|WFLG_REPORTMOUSE|WFLG_RMBTRAP|WFLG_ACTIVATE,
WA_PubScreen, data->scr,
WA_IDCMP, IDCMP_MOUSEBUTTONS|IDCMP_MOUSEMOVE,
TAG_END)))
{
if(appport=(struct MsgPort *)CreateMsgPort())
{
appwin=(struct AppWindow *)AddAppWindow(0L, 0L, lwin, appport , 0L);
appwinsig= 1L << appport->mp_SigBit;
}
selected =-1;
lastsel =-1;
window_mask = 1L << data->win->UserPort->mp_SigBit;
lwindow_mask = 1L << lwin->UserPort->mp_SigBit;
SetFont(rp=lwin->RPort,data->Font[ID]);
SetAPen(rp,pen_bg); RectFill(rp,0,0,width-1,height-1);
draw_border_new(rp,0,0,width,height,pen_bright,pen_dark);
SetAPen(rp,pen_entry);
SetDrMd(rp,JAM1);
foobar=entry;
dummy=0;
do
{
if(foobar->img)
{
GetDTAttrs(foobar->img,PDTA_BitMapHeader,&bmhd,TAG_DONE);
DrawDTObject(foobar->img,0,0,rp,2+((iw-bmhd->bmh_Width)>>1),(dummy*entryheight)+1+((entryheight-bmhd->bmh_Height)>>1),-1,-1,trans);
}
Move(rp,iw+7,((dummy++)*entryheight)+y_pos+1);
Text(rp,foobar->lau_lbl,my_strlen(foobar->lau_lbl));
}
while(foobar=foobar->next);
while(foo)
{
sigs=Wait( window_mask | lwindow_mask | appwinsig );
if(sigs & appwinsig)
{
struct AppMessage *apm;
while(apm=(struct AppMessage *)GetMsg(appport))
{
selected=(apm->am_MouseY-1)/entryheight;
for(foobar=entry,dummy=0;dummy<selected;dummy++)foobar=foobar->next;
if(apm->am_Type==AMTYPE_APPWINDOW)
{
RunFile(foobar,data,apm->am_ArgList,apm->am_NumArgs);
}
ReplyMsg((struct Message *)apm);
}
}
if(sigs & window_mask)
{
while(m=(struct IntuiMessage *)GetMsg(data->win->UserPort))
{
switch (m->Class)
{
case IDCMP_GADGETDOWN:
foo=FALSE;
break;
}
ReplyMsg((struct Message *)m);
}
}
if(sigs & lwindow_mask)
{
while(m=(struct IntuiMessage *)GetMsg(lwin->UserPort))
{
switch (m->Class)
{
case IDCMP_MOUSEBUTTONS:
if((m->Code&15)==8)
{
selected=(m->MouseY-1)/entryheight;
foo=FALSE;
start=TRUE;
}
break;
case IDCMP_MOUSEMOVE:
x=m->MouseX;
y=m->MouseY;
if((x>0)&&(y>0)&&(x<(width-1))&&(y<(height-1)))
{
selected=(y-1)/entryheight;
if(selected!=lastsel)
{
if(lastsel!=-1)
{
SetAPen(rp,pen_bg);
RectFill(rp,iw+3,1+(lastsel*entryheight),width-4,((lastsel+1)*entryheight));
SetAPen(rp,pen_entry);
for(foobar=entry,dummy=0;dummy<lastsel;dummy++)foobar=foobar->next;
Move(rp,iw+7,(lastsel*entryheight)+y_pos+1);
Text(rp,foobar->lau_lbl,my_strlen(foobar->lau_lbl));
}
SetAPen(rp,pen_cur);
RectFill(rp,iw+3,1+(selected*entryheight),width-4,((selected+1)*entryheight));
SetAPen(rp,pen_entry);
for(foobar=entry,dummy=0;dummy<selected;dummy++)foobar=foobar->next;
Move(rp,iw+7,(selected*entryheight)+y_pos+1);
Text(rp,foobar->lau_lbl,my_strlen(foobar->lau_lbl));
}
lastsel=selected;
}
else
{
if(lastsel!=-1)
{
SetAPen(rp,pen_bg);
RectFill(rp,iw+1,1+(lastsel*entryheight),width-2,((lastsel+1)*entryheight));
SetAPen(rp,pen_entry);
for(foobar=entry,dummy=0;dummy<lastsel;dummy++)foobar=foobar->next;
Move(rp,iw+7,(lastsel*entryheight)+y_pos+1);
Text(rp,foobar->lau_lbl,my_strlen(foobar->lau_lbl));
}
selected=-1;
lastsel=-1;
}
break;
}
ReplyMsg((struct Message *)m);
}
}
}
while(m=(struct IntuiMessage *)GetMsg(data->win->UserPort))ReplyMsg((struct Message *)m);
while(m=(struct IntuiMessage *)GetMsg(lwin->UserPort)) ReplyMsg((struct Message *)m);
if(appwin) RemoveAppWindow(appwin);
if(appport) DeletePort(appport);
CloseWindow(lwin);
if(start&&(selected>-1))
{
for(foobar=entry,dummy=0;dummy<selected;dummy++)foobar=foobar->next;
RunFile(foobar,data,wbarg,numarg);
}
}
else DisplayBeep(0);
}
}
struct tm_sys_set *handler(struct tm_sys_set *set, struct tm_data *data, struct MsgPort *broker_mp, CxObj *broker, ULONG cxsigflag, Class *gclass, Class *lclass)
{
BOOL running = TRUE;
ULONG mem_val=0,
vol_val=0,
sigs,
window_mask,
my_time_mask_clock,
my_test_port_mask,
my_noti_port_mask=0L,
my_app_port_mask =0L,
my_handler;
struct MsgPort *my_time_port_clock,
*my_test_port,
*my_noti_port;
struct timerequest *my_time_request_clock;
struct NotifyRequest *notifyrequest;
LONG not_sig;
BOOL closed=FALSE;
struct IntuiMessage *m;
int i;
struct TestMessage *test_msg;
struct tm_gau_set *many,*next;
BOOL first_run=TRUE,doit;
UWORD do_what;
if(data->scrnot)
{
my_noti_port = (struct MsgPort *)CreateMsgPort();
my_handler = ((!data->on_public)|(!strcmp(&set->pub_name[0],"Workbench"))) ? (ULONG)AddWorkbenchClient(my_noti_port,0) : (ULONG)AddCloseScreenClient(data->scr,my_noti_port,0);
my_noti_port_mask = 1L << my_noti_port->mp_SigBit;
}
if(data->appwin) my_app_port_mask = 1L << data->appport->mp_SigBit;
window_mask = 1L << data->win->UserPort->mp_SigBit;
if(my_test_port=(struct MsgPort *)CreatePort("TinyMeter",0))
{
my_test_port_mask = 1L << (my_test_port->mp_SigBit);
if(my_time_port_clock=(struct MsgPort *)CreateMsgPort())
{
my_time_mask_clock = 1L << (my_time_port_clock->mp_SigBit);
if(my_time_request_clock = (struct timerequest *)CreateIORequest(my_time_port_clock,sizeof(struct timerequest)))
{
if(!OpenDevice("timer.device",UNIT_WAITUNTIL,(struct IORequest *)my_time_request_clock,NULL))
{
if(notifyrequest = (struct NotifyRequest *)pAllocVec(sizeof(struct NotifyRequest)))
{
if ((not_sig = AllocSignal(-1L)) != -1)
{
notifyrequest->nr_Name = "ENV:Sys/WBPattern.prefs";
notifyrequest->nr_Flags = NRF_SEND_SIGNAL;
notifyrequest->nr_stuff.nr_Signal.nr_Task = (struct Task *) FindTask(NULL);
notifyrequest->nr_stuff.nr_Signal.nr_SignalNum = not_sig;
if((StartNotify(notifyrequest))==DOSTRUE)
{
init_time_request(my_time_request_clock,my_time_mask_clock);
while(running)
{
sigs = Wait( my_noti_port_mask | my_test_port_mask | window_mask | my_time_mask_clock | (1L << not_sig) | cxsigflag | my_app_port_mask );
if(!closed)
{
if (sigs & my_time_mask_clock)
{
WaitIO((struct IORequest *)my_time_request_clock);
init_time_request(my_time_request_clock,my_time_mask_clock);
do_what=do_clock;
mem_val++;
if(mem_val>=set->mem_refresh)
{
mem_val=0;
do_what=do_mem;
}
vol_val++;
if(vol_val>=set->vol_refresh)
{
vol_val=0;
do_what=do_vol;
}
for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
{
doit=FALSE;
if(data->gdg[i])
switch (do_what)
{
case do_vol:
if(many->type==typ_volume) { doit=TRUE; break; }
case do_mem:
if((many->type!=typ_none)&&(many->type!=typ_iconlauncher)&&(many->type!=typ_simplelauncher)&&(many->type!=typ_volume)) { doit=TRUE; break; }
default:
if(many->type==typ_clock_) doit=TRUE;
break;
}
if(doit) DoMethod((Object *)data->gdg[i],MY_REFRESH,data->win,NULL);
}
if(first_run){setBase(data);first_run=FALSE;}
if(set->win_backfront==win_front) if(data->win->WLayer!=data->scr->LayerInfo.top_layer) WindowToFront(data->win);
}
if (sigs & my_app_port_mask)
{
struct AppMessage *appmsg;
while(appmsg=(struct AppMessage *)GetMsg( data->appport))
{
if(appmsg->am_Type=AMTYPE_APPWINDOW)
{
for(i=0,many=data->list;i<data->num_of_gaug;i++,many=many->next)
{
if((many->type==typ_simplelauncher)||(many->type==typ_iconlauncher))
if(data->gdg[i])
{
if((data->gdg[i]->TopEdge <appmsg->am_MouseY)&&((data->gdg[i]->TopEdge +data->gdg[i]->Height)>appmsg->am_MouseY)&&
(data->gdg[i]->LeftEdge<appmsg->am_MouseX)&&((data->gdg[i]->LeftEdge+data->gdg[i]->Width) >appmsg->am_MouseX)
)
{
if(data->gdg[i]->GadgetID<0xFFF0)
{
struct lau_entry *entry;
GetAttr(LAU_List,(Object *)data->gdg[i],(ULONG *)&entry);
if(many->type==typ_simplelauncher)
{
if(entry->next) handle_launcher (data,(UWORD)data->gdg[i]->GadgetID,(struct Gadget *)data->gdg[i],appmsg->am_ArgList,appmsg->am_NumArgs);
else RunFile (entry,data,appmsg->am_ArgList,appmsg->am_NumArgs);
}
else
{
ULONG fullness;
struct BitMapHeader *bmhd;
WORD x=appmsg->am_MouseX-data->gdg[i]->LeftEdge;
GetAttr(LAU_XPos,(Object *)data->gdg[i],&fullness);
if(entry)
{
do
{
if(entry->img)
{
GetDTAttrs(entry->img,PDTA_BitMapHeader,&bmhd,TAG_DONE);
if(bmhd)
{
if(((fullness+bmhd->bmh_Width)>x)&&(fullness<x)) break;
fullness+=bmhd->bmh_Width;
}
}
}
while(entry=entry->next);
RunFile(entry,data,appmsg->am_ArgList,appmsg->am_NumArgs);
}
}
}
}
}
}
}
ReplyMsg((struct Message *)appmsg);
}
}
if (sigs & window_mask)
{
while(m=(struct IntuiMessage *)GetMsg( data->win->UserPort ))
{
switch ( m->Class )
{
case IDCMP_GADGETDOWN:
{
WORD x;
struct Gadget *g=((struct Gadget *)(m->IAddress));
x=m->MouseX-g->LeftEdge;
ReplyMsg((struct Message *)m);
if(g->GadgetID<0xFFF0)
{
struct lau_entry *entry;
ULONG type;
GetAttr(LAU_List,(Object *)g,(ULONG *)&entry);
GetAttr(LAU_Type,g,&type);
if(type==typ_iconlauncher)
{
ULONG fullness;
struct BitMapHeader *bmhd;
GetAttr(LAU_XPos,(Object *)g,&fullness);
if(entry)
{
do
{
if(entry->img)
{
GetDTAttrs(entry->img,PDTA_BitMapHeader,&bmhd,TAG_DONE);
if(bmhd)
{
if((x<(fullness+bmhd->bmh_Width))&&(x>fullness)) break;
fullness+=bmhd->bmh_Width;
}
}
}
while(entry=entry->next);
RunFile(entry,data,NULL,NULL);
}
}
else if(entry->next) handle_launcher(data,(UWORD)g->GadgetID,(struct Gadget *)g,NULL,NULL);
else RunFile(entry,data,NULL,NULL);
}
}
break;
case IDCMP_CHANGEWINDOW:
ReplyMsg((struct Message *)m);
if(set->bg_type==bg_snap) window_mask=snapSub(set,data);
break;
case IDCMP_CLOSEWINDOW:
running=FALSE;
ReplyMsg((struct Message *)m);
break;
case IDCMP_NEWSIZE:
ReplyMsg((struct Message *)m);
new_window_size(set,data);
set->x_siz=data->win->Width;
data->gauge_x_size=(set->x_siz-(set->win_border_x<<1)-((set->colums-1)*set->win_space_x))/set->colums;
if(set->bg_type==bg_file) fileBackground(set,data);
drawBackground(set,data);
for(i=0;i<data->num_of_gaug;i++) if(data->gdg[i]) SetAttrs(data->gdg[i],GA_Left,set->win_border_x+((i)%set->colums)*data->gauge_x_size+((i)%set->colums)*set->win_space_x,GA_Width,data->gauge_x_size,TAG_DONE);
if(set->bg_type!=bg_snap)RefreshGList(data->win->FirstGadget,data->win,NULL,-1);
if(set->bg_type==bg_snap)window_mask=snapSub(set,data);
break;
case IDCMP_VANILLAKEY:
{
int Code=m->Code;
ReplyMsg((struct Message *)m);
switch(Code)
{
case 'S':
case 's':
{
BPTR my_file,my_file1;
set->x_pos=data->win->LeftEdge;
set->y_pos=data->win->TopEdge;
set->x_siz=data->win->Width;
my_file= (BPTR)Open("ENV:TinyMeter", MODE_NEWFILE);
my_file1=(BPTR)Open("ENVARC:TinyMeter",MODE_NEWFILE);
if(my_file) Write(my_file, set,(ULONG) sizeof(struct tm_sys_set));
if(my_file1)Write(my_file1,set,(ULONG) sizeof(struct tm_sys_set));
many=data->list;
for(i=0;i<data->num_of_gaug;i++)
{
if(my_file) Write(my_file, many,(ULONG) sizeof(struct tm_gau_set));
if(my_file1)Write(my_file1,many,(ULONG) sizeof(struct tm_gau_set));
many=many->next;
}
if(my_file) Close(my_file1);
if(my_file1)Close(my_file);
}
break;
case 'F':
case 'f':
{
void *my_mem;
Forbid();
my_mem=AllocVec(2000000000L,MEMF_PUBLIC);
if(my_mem)FreeVec((APTR)my_mem);
Permit();
}
break;
case 'Q':
case 'q':
running=FALSE;
break;
case 'b':
case 'B':
if(set->bg_type==bg_snap)window_mask=snapSub(set,data);
break;
}
}
break;
case IDCMP_MOUSEBUTTONS:
if((m->Code&129)==1) setBase(data);
default :
ReplyMsg((struct Message *)m);
break;
}
}
}
if (sigs & (1L << not_sig))
{
Delay(100L);
if(set->bg_type==bg_snap) window_mask=snapSub(set,data);
}
}
else if (sigs & my_time_mask_clock) init_time_request(my_time_request_clock,my_time_mask_clock);
if (sigs & cxsigflag)
{
CxMsg *msg;
ULONG msgid, msgtype;
while(msg = (CxMsg *)GetMsg(broker_mp))
{
msgid = CxMsgID(msg);
msgtype = CxMsgType(msg);
ReplyMsg((struct Message *)msg);
if(msgtype==CXM_COMMAND)
{
switch(msgid)
{
case CXCMD_DISABLE:
{
BOOL pause=TRUE;
ActivateCxObj(broker, 0L);
while(pause)
{
Wait(cxsigflag);
while(msg = (CxMsg *)GetMsg(broker_mp))
{
msgid = CxMsgID(msg);
msgtype = CxMsgType(msg);
ReplyMsg((struct Message *)msg);
if(msgtype==CXM_COMMAND) if(msgid==CXCMD_ENABLE) pause=FALSE;
}
}
ActivateCxObj(broker, 1L);
}
break;
case CXCMD_KILL:
running=FALSE;
case CXCMD_ENABLE:
ActivateCxObj(broker, 1L);
default:
break;
}
}
}
}
if ((sigs & my_test_port_mask)&&(!closed))
{
while(test_msg=(struct TestMessage *)GetMsg(my_test_port))
{
switch (test_msg->MethodID)
{
case test_test:
if(test_msg->set && test_msg->list)
{
struct tm_gau_set *manyn,*nextn;
closeWindow(set,data);
first_run=TRUE;
pFreeVec((ULONG *)set);
many=data->list;
do
{
next=many->next;
pFreeVec((ULONG *)many);
}
while(many=next);
if(set=(struct tm_sys_set *)pAllocVec(sizeof(struct tm_sys_set)))
{
CopyMem(test_msg->set,set,sizeof(struct tm_sys_set));
}
else running=FALSE;
data->num_of_gaug = getNum(test_msg->list);
many = test_msg->list;
if(!(nextn=(struct tm_gau_set *)pAllocVec(sizeof(struct tm_gau_set)))){return(set);}
data->list = nextn;
for(i=0;i<data->num_of_gaug;i++)
{
manyn=nextn;
if(!(nextn=(struct tm_gau_set *)pAllocVec(sizeof(struct tm_gau_set)))){return(set);}
CopyMem(many,manyn,sizeof(struct tm_gau_set));
manyn->next=nextn;
many=many->next;
}
pFreeVec((ULONG *)nextn);
manyn->next=NULL;
if(openWindow(set,data,gclass,lclass))
{
window_mask = 1L << data->win->UserPort->mp_SigBit;
}
else return(set);
setBase(data);
}
break;
case test_getwin:
test_msg->posx=data->win->LeftEdge;
test_msg->posy=data->win->TopEdge;
test_msg->sizx=data->win->Width;
break;
}
ReplyMsg((struct Message *)test_msg);
}
}
if(data->scrnot)
{
if (sigs & my_noti_port_mask)
{
struct ScreenNotifyMessage *snm;
while(snm = (struct ScreenNotifyMessage *) GetMsg(my_noti_port))
{
switch(snm->snm_Type)
{
case SCREENNOTIFY_TYPE_CLOSESCREEN:
running=FALSE;
break;
case SCREENNOTIFY_TYPE_WORKBENCH:
if((ULONG)snm->snm_Value)
{
if(closed)
{
Delay(50L);
if(openWindow(set,data,gclass,lclass))
{
window_mask = 1L << data->win->UserPort->mp_SigBit;
closed=FALSE;
}
else running=FALSE;
setBase(data);
}
}
else
{
if(!closed)
{
closeWindow(set,data);
closed=TRUE;
}
first_run=TRUE;
}
break;
}
ReplyMsg((struct Message *) snm);
}
}
}
}
EndNotify(notifyrequest);
}
else show(err_nosta);
FreeSignal(not_sig);
}
else show(err_nosta);
pFreeVec((ULONG *)notifyrequest);
}
else show(err_nomem);
if(!CheckIO((struct IORequest *)my_time_request_clock))
AbortIO((struct IORequest *)my_time_request_clock);
WaitIO((struct IORequest *)my_time_request_clock);
CloseDevice((struct IORequest *)my_time_request_clock);
}
else show(err_nodev);
DeleteIORequest((struct IORequest *)my_time_request_clock);
}
else show(err_nopor);
DeleteMsgPort((struct MsgPort *)my_time_port_clock);
}
else show(err_nopor);
DeletePort(my_test_port);
}
else show(err_nopor);
if(data->scrnot)
{
if((!data->on_public)|(!strcmp(&set->pub_name[0],"Workbench")))
while(!RemWorkbenchClient((APTR)my_handler)) Delay(10);
else
while(!RemCloseScreenClient((APTR)my_handler)) Delay(10);
DeleteMsgPort(my_noti_port);
}
return(set);
}